package service

import (
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"time"
)

type IJwt interface {
	EncryptUserToken()
	DecodeUserToken()
}
type Jwt struct{}

func NewJwt() *Jwt {
	return &Jwt{}
}

// MyPayload 定义负载继承jwt的标准负载
type MyPayload struct {
	Username string
	jwt.StandardClaims
}

// 定义secret签名
var signatureKey []byte = []byte("!@#qwe")

// EncryptUserToken 生成加密token
func (j Jwt) EncryptUserToken(user string) string {
	//传入用户信息生成负载实例
	payload := MyPayload{
		Username: user,
		StandardClaims: jwt.StandardClaims{
			NotBefore: time.Now().Unix() + 10,   //表示令牌在当前时间后的 10 秒后才可用。
			ExpiresAt: time.Now().Unix() + 3600, //  表示令牌的过期时间是当前时间开始，一小时后失效
		},
	}

	//生成加密Signature
	token, err := jwt.NewWithClaims(jwt.SigningMethodHS256, payload).SignedString(signatureKey)
	if err != nil {
		panic(err)
	}
	return token
}

// DecodeUserToken 解密token
func (j Jwt) DecodeUserToken(token string) (*MyPayload, error) {
	//解密后jwt.Token对象，从该对象可以获取Header，Payload，Signature（claims）等信息
	unsafeToken, err := jwt.ParseWithClaims(token, &MyPayload{}, func(token *jwt.Token) (interface{}, error) {
		return signatureKey, nil
	})

	fmt.Println("======2222==========")

	if claims, ok := unsafeToken.Claims.(*MyPayload); ok && unsafeToken.Valid {
		fmt.Printf("%v %v", claims.Username, claims.StandardClaims.ExpiresAt)
	} else {
		fmt.Println(err)
	}

	fmt.Println("================")

	//将负载转化为结构体
	claims, ok := unsafeToken.Claims.(*MyPayload)
	fmt.Println("================")
	fmt.Println(claims)
	fmt.Println("================")

	if ok && unsafeToken.Valid {
		return claims, nil
	} else {
		return claims, err
	}

	/*
		//验证token是否有效
		if unsafeToken.Valid {
			//错误判断并返回错误信息
			if err1 != nil {
				return "未携带有效token", unsafeToken.Claims
			} else if ve, ok := err1.(*jwt.ValidationError); ok {
				if ve.Errors&jwt.ValidationErrorMalformed != 0 {
					return "无效token", nil
				} else if ve.Errors&(jwt.ValidationErrorExpired|jwt.ValidationErrorNotValidYet) != 0 {
					return "token已过期", nil
				} else {
					return "", nil
				}
			}
		}
	*/

}
